home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / sound / pcm_params.h < prev    next >
C/C++ Source or Header  |  2006-01-09  |  8KB  |  367 lines
  1. #ifndef __SOUND_PCM_PARAMS_H
  2. #define __SOUND_PCM_PARAMS_H
  3.  
  4. /*
  5.  *  PCM params helpers
  6.  *  Copyright (c) by Abramo Bagnara <abramo@alsa-project.org>
  7.  *
  8.  *
  9.  *   This program is free software; you can redistribute it and/or modify
  10.  *   it under the terms of the GNU General Public License as published by
  11.  *   the Free Software Foundation; either version 2 of the License, or
  12.  *   (at your option) any later version.
  13.  *
  14.  *   This program is distributed in the hope that it will be useful,
  15.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  *   GNU General Public License for more details.
  18.  *
  19.  *   You should have received a copy of the GNU General Public License
  20.  *   along with this program; if not, write to the Free Software
  21.  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  22.  *
  23.  */
  24.  
  25. extern int snd_pcm_hw_param_mask(snd_pcm_substream_t *pcm, snd_pcm_hw_params_t *params,
  26.                  snd_pcm_hw_param_t var, const snd_mask_t *val);
  27. extern unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params,
  28.                            snd_pcm_hw_param_t var, int *dir);
  29. extern unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params,
  30.                            snd_pcm_hw_param_t var, int *dir);
  31. extern int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params,
  32.                  snd_pcm_hw_param_t var, unsigned int val, int dir);
  33. extern int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params,
  34.                     snd_pcm_hw_param_t var);
  35. extern int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params,
  36.                  snd_pcm_hw_param_t var, unsigned int val, int dir);
  37.  
  38. /* To share the same code we have  alsa-lib */
  39. #define INLINE static inline
  40. #define assert(a) (void)(a)
  41.  
  42. #define SNDRV_MASK_BITS    64    /* we use so far 64bits only */
  43. #define SNDRV_MASK_SIZE    (SNDRV_MASK_BITS / 32)
  44. #define MASK_OFS(i)    ((i) >> 5)
  45. #define MASK_BIT(i)    (1U << ((i) & 31))
  46.  
  47. INLINE unsigned int ld2(u_int32_t v)
  48. {
  49.         unsigned r = 0;
  50.  
  51.         if (v >= 0x10000) {
  52.                 v >>= 16;
  53.                 r += 16;
  54.         }
  55.         if (v >= 0x100) {
  56.                 v >>= 8;
  57.                 r += 8;
  58.         }
  59.         if (v >= 0x10) {
  60.                 v >>= 4;
  61.                 r += 4;
  62.         }
  63.         if (v >= 4) {
  64.                 v >>= 2;
  65.                 r += 2;
  66.         }
  67.         if (v >= 2)
  68.                 r++;
  69.         return r;
  70. }
  71.  
  72. INLINE size_t snd_mask_sizeof(void)
  73. {
  74.     return sizeof(snd_mask_t);
  75. }
  76.  
  77. INLINE void snd_mask_none(snd_mask_t *mask)
  78. {
  79.     memset(mask, 0, sizeof(*mask));
  80. }
  81.  
  82. INLINE void snd_mask_any(snd_mask_t *mask)
  83. {
  84.     memset(mask, 0xff, SNDRV_MASK_SIZE * sizeof(u_int32_t));
  85. }
  86.  
  87. INLINE int snd_mask_empty(const snd_mask_t *mask)
  88. {
  89.     int i;
  90.     for (i = 0; i < SNDRV_MASK_SIZE; i++)
  91.         if (mask->bits[i])
  92.             return 0;
  93.     return 1;
  94. }
  95.  
  96. INLINE unsigned int snd_mask_min(const snd_mask_t *mask)
  97. {
  98.     int i;
  99.     assert(!snd_mask_empty(mask));
  100.     for (i = 0; i < SNDRV_MASK_SIZE; i++) {
  101.         if (mask->bits[i])
  102.             return ffs(mask->bits[i]) - 1 + (i << 5);
  103.     }
  104.     return 0;
  105. }
  106.  
  107. INLINE unsigned int snd_mask_max(const snd_mask_t *mask)
  108. {
  109.     int i;
  110.     assert(!snd_mask_empty(mask));
  111.     for (i = SNDRV_MASK_SIZE - 1; i >= 0; i--) {
  112.         if (mask->bits[i])
  113.             return ld2(mask->bits[i]) + (i << 5);
  114.     }
  115.     return 0;
  116. }
  117.  
  118. INLINE void snd_mask_set(snd_mask_t *mask, unsigned int val)
  119. {
  120.     assert(val <= SNDRV_MASK_BITS);
  121.     mask->bits[MASK_OFS(val)] |= MASK_BIT(val);
  122. }
  123.  
  124. INLINE void snd_mask_reset(snd_mask_t *mask, unsigned int val)
  125. {
  126.     assert(val <= SNDRV_MASK_BITS);
  127.     mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val);
  128. }
  129.  
  130. INLINE void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int to)
  131. {
  132.     unsigned int i;
  133.     assert(to <= SNDRV_MASK_BITS && from <= to);
  134.     for (i = from; i <= to; i++)
  135.         mask->bits[MASK_OFS(i)] |= MASK_BIT(i);
  136. }
  137.  
  138. INLINE void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned int to)
  139. {
  140.     unsigned int i;
  141.     assert(to <= SNDRV_MASK_BITS && from <= to);
  142.     for (i = from; i <= to; i++)
  143.         mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i);
  144. }
  145.  
  146. INLINE void snd_mask_leave(snd_mask_t *mask, unsigned int val)
  147. {
  148.     unsigned int v;
  149.     assert(val <= SNDRV_MASK_BITS);
  150.     v = mask->bits[MASK_OFS(val)] & MASK_BIT(val);
  151.     snd_mask_none(mask);
  152.     mask->bits[MASK_OFS(val)] = v;
  153. }
  154.  
  155. INLINE void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v)
  156. {
  157.     int i;
  158.     for (i = 0; i < SNDRV_MASK_SIZE; i++)
  159.         mask->bits[i] &= v->bits[i];
  160. }
  161.  
  162. INLINE int snd_mask_eq(const snd_mask_t *mask, const snd_mask_t *v)
  163. {
  164.     return ! memcmp(mask, v, SNDRV_MASK_SIZE * sizeof(u_int32_t));
  165. }
  166.  
  167. INLINE void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v)
  168. {
  169.     *mask = *v;
  170. }
  171.  
  172. INLINE int snd_mask_test(const snd_mask_t *mask, unsigned int val)
  173. {
  174.     assert(val <= SNDRV_MASK_BITS);
  175.     return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
  176. }
  177.  
  178. INLINE int snd_mask_single(const snd_mask_t *mask)
  179. {
  180.     int i, c = 0;
  181.     assert(!snd_mask_empty(mask));
  182.     for (i = 0; i < SNDRV_MASK_SIZE; i++) {
  183.         if (! mask->bits[i])
  184.             continue;
  185.         if (mask->bits[i] & (mask->bits[i] - 1))
  186.             return 0;
  187.         if (c)
  188.             return 0;
  189.         c++;
  190.     }
  191.     return 1;
  192. }
  193.  
  194. INLINE int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v)
  195. {
  196.     snd_mask_t old;
  197.     assert(!snd_mask_empty(mask));
  198.     snd_mask_copy(&old, mask);
  199.     snd_mask_intersect(mask, v);
  200.     if (snd_mask_empty(mask))
  201.         return -EINVAL;
  202.     return !snd_mask_eq(mask, &old);
  203. }
  204.  
  205. INLINE int snd_mask_refine_first(snd_mask_t *mask)
  206. {
  207.     assert(!snd_mask_empty(mask));
  208.     if (snd_mask_single(mask))
  209.         return 0;
  210.     snd_mask_leave(mask, snd_mask_min(mask));
  211.     return 1;
  212. }
  213.  
  214. INLINE int snd_mask_refine_last(snd_mask_t *mask)
  215. {
  216.     assert(!snd_mask_empty(mask));
  217.     if (snd_mask_single(mask))
  218.         return 0;
  219.     snd_mask_leave(mask, snd_mask_max(mask));
  220.     return 1;
  221. }
  222.  
  223. INLINE int snd_mask_refine_min(snd_mask_t *mask, unsigned int val)
  224. {
  225.     assert(!snd_mask_empty(mask));
  226.     if (snd_mask_min(mask) >= val)
  227.         return 0;
  228.     snd_mask_reset_range(mask, 0, val - 1);
  229.     if (snd_mask_empty(mask))
  230.         return -EINVAL;
  231.     return 1;
  232. }
  233.  
  234. INLINE int snd_mask_refine_max(snd_mask_t *mask, unsigned int val)
  235. {
  236.     assert(!snd_mask_empty(mask));
  237.     if (snd_mask_max(mask) <= val)
  238.         return 0;
  239.     snd_mask_reset_range(mask, val + 1, SNDRV_MASK_BITS);
  240.     if (snd_mask_empty(mask))
  241.         return -EINVAL;
  242.     return 1;
  243. }
  244.  
  245. INLINE int snd_mask_refine_set(snd_mask_t *mask, unsigned int val)
  246. {
  247.     int changed;
  248.     assert(!snd_mask_empty(mask));
  249.     changed = !snd_mask_single(mask);
  250.     snd_mask_leave(mask, val);
  251.     if (snd_mask_empty(mask))
  252.         return -EINVAL;
  253.     return changed;
  254. }
  255.  
  256. INLINE int snd_mask_value(const snd_mask_t *mask)
  257. {
  258.     assert(!snd_mask_empty(mask));
  259.     return snd_mask_min(mask);
  260. }
  261.  
  262. INLINE void snd_interval_any(snd_interval_t *i)
  263. {
  264.     i->min = 0;
  265.     i->openmin = 0;
  266.     i->max = UINT_MAX;
  267.     i->openmax = 0;
  268.     i->integer = 0;
  269.     i->empty = 0;
  270. }
  271.  
  272. INLINE void snd_interval_none(snd_interval_t *i)
  273. {
  274.     i->empty = 1;
  275. }
  276.  
  277. INLINE int snd_interval_checkempty(const snd_interval_t *i)
  278. {
  279.     return (i->min > i->max ||
  280.         (i->min == i->max && (i->openmin || i->openmax)));
  281. }
  282.  
  283. INLINE int snd_interval_empty(const snd_interval_t *i)
  284. {
  285.     return i->empty;
  286. }
  287.  
  288. INLINE int snd_interval_single(const snd_interval_t *i)
  289. {
  290.     assert(!snd_interval_empty(i));
  291.     return (i->min == i->max || 
  292.         (i->min + 1 == i->max && i->openmax));
  293. }
  294.  
  295. INLINE int snd_interval_value(const snd_interval_t *i)
  296. {
  297.     assert(snd_interval_single(i));
  298.     return i->min;
  299. }
  300.  
  301. INLINE int snd_interval_min(const snd_interval_t *i)
  302. {
  303.     assert(!snd_interval_empty(i));
  304.     return i->min;
  305. }
  306.  
  307. INLINE int snd_interval_max(const snd_interval_t *i)
  308. {
  309.     unsigned int v;
  310.     assert(!snd_interval_empty(i));
  311.     v = i->max;
  312.     if (i->openmax)
  313.         v--;
  314.     return v;
  315. }
  316.  
  317. INLINE int snd_interval_test(const snd_interval_t *i, unsigned int val)
  318. {
  319.     return !((i->min > val || (i->min == val && i->openmin) ||
  320.           i->max < val || (i->max == val && i->openmax)));
  321. }
  322.  
  323. INLINE void snd_interval_copy(snd_interval_t *d, const snd_interval_t *s)
  324. {
  325.     *d = *s;
  326. }
  327.  
  328. INLINE int snd_interval_setinteger(snd_interval_t *i)
  329. {
  330.     if (i->integer)
  331.         return 0;
  332.     if (i->openmin && i->openmax && i->min == i->max)
  333.         return -EINVAL;
  334.     i->integer = 1;
  335.     return 1;
  336. }
  337.  
  338. INLINE int snd_interval_eq(const snd_interval_t *i1, const snd_interval_t *i2)
  339. {
  340.     if (i1->empty)
  341.         return i2->empty;
  342.     if (i2->empty)
  343.         return i1->empty;
  344.     return i1->min == i2->min && i1->openmin == i2->openmin &&
  345.         i1->max == i2->max && i1->openmax == i2->openmax;
  346. }
  347.  
  348. static inline unsigned int add(unsigned int a, unsigned int b)
  349. {
  350.     if (a >= UINT_MAX - b)
  351.         return UINT_MAX;
  352.     return a + b;
  353. }
  354.  
  355. static inline unsigned int sub(unsigned int a, unsigned int b)
  356. {
  357.     if (a > b)
  358.         return a - b;
  359.     return 0;
  360. }
  361.  
  362. #undef INLINE
  363. #undef assert
  364.  
  365. #endif /* __SOUND_PCM_PARAMS_H */
  366.  
  367.